Práctica 06: Perceptron de una capa

Integrantes:
Contenido

Objetivos

Introducción

El articulo aborda la manera en la que el modelo del preceptron es un modelo que se asemeja a o podria plantearse como una alternativa al entendimiento de como el cerebro procesa la información.
Se comienza plantenando tres preguntas fundamentales que como seres humanos realizamos dia a dia aun que raramente nos detenemos a reflexionar el como suceden, y es relacionado a la manera en la que procesamos la información, partiendo de ¿como son detectados los estimulos que nos proven cierta información?, ¿Como es esta información almacenda? y por ultimo, ¿como esta información influye en nuestr comportameinto o en la manera en la que reconocemos las cosas?.
Principalmente centrandose en las ultimas dos preguntas, y partiendo por la primera de estas dos. Se plantea que el cerebro almacena información en forma de codigos o imagenes en un modo de clasificación de el estimulo recibido con un patronalmacenado o aprendido. Por otro lado tambien se plantea que en realidad el cerebro no realiza un almacenamiento como tal, sino que en el sistema nervioso central (SNC), se crean nuevas rutas hacia ciertas zonas del cerebro con lo que los estimulos entrantesseria mas equiparados a una idea que una acción concreta. De otro modo se puede decir que la primer idea cataloga un estimulo con cierto patron , y la segunda asocia ciertas caracteristicas de dicho estimulo creando una asociaciones de elementos de dicho estumulo sin catalogarlo perse.
Teniendo en cuenta estas dos hipotessis de "almacenamiento" de la información la respuesta a la tecer pregunta, para la primera hipotesis se basa en que al compararse de manera sistematica los estimulos entrantes con los ya clasificados, de la misma manera se determina el comportamiento a los estimulos dentro de las mimmas "clases" de almacenamiento mientras que de acuerdo a la segunda hipotesis, los estimulos entrantes seguiran los mismos caminos (o al menos caminos parecidos) a los que correspondientes a estimulos anteriores a estos.
Esta ultima teoria llamada "Coneccionista" seria la manera enla que el perceptron toma decisiones.
De esta manera conociendo la manera en la que trabaja el perceptron podriamos decir que cada vez que se entra una red de esta arquitectura y los pesos y desviaciones se ajustan, seria similar a la manera en la que un estimulo seguiria un mismo camino o uno parecido al de un estimilo similar que entro anteriormente mientras que estos mismos cominos serian los formados con cada entrenamiento, por lo que despues de muchas decadas de entrenamiento los estimulos asociados a ciertos patrones tendrian aociada de manera practicamente inmediata la respuesta a la que estan asociados estos tipos de estimulos.
Otro punto importante tambien a tomar en cuenta es que no todos los SNC son iguales por lo que su ruta de aprendizaje es distinta, esto en similitud en la manera en la que se incia elaprendizaje de un perceptron indicaria la manera en la que como todos estos sstemas apprende en algunas ocaciones mas o menos rapido.

Problemas

Problema 1

Elabore una función que entrene un perceptron de 1 capa y S neuronas. Para ello considere lo siguiente:
El numeró de neuronas debe de elegirse de acuerdo a la dimensión t (¿por qué?)
Porque la cantidad de clases máximas que una arquitectura puede clasifica depende del número de neuronas, más específicamente
será el número máximo de clases que un perceptrón de S neuronas puede clasificar
Puede iniciaizar los parámetros con numeros aleatorios pequeños incluso pueden ser cero.
El programa debe deternerse de acuerdo a diferentes criterios:
- Se logro el entrenamiento antes del numero de epocas indicado, se indica que esto ocurre
- Se alcanzo el número de epocas ingresado, se debe indicar si con esta selección se logro o no el entrenamiento
- Se logro la tolerancia indicada (en caso de ser ingresada). Es decir, si
donde la resta es entre los parametros estimados en la epoca i e , con la norma usual (aunque algunos algortimos utilizan la norma infinito, puedes implementar esta en lugar de la norma 2, si así lo deseas). Se despliega un menaje para indicar que esto ocurrio
function [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
end
numClase(tt) = cont;
end
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% fin numero de clases
% disp(neuronas)
% Generar los pesos y desviaciones
rng(0,'twister');
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
% W = numr x neuronas
% W = [0; 0];
% b = [0];
% W = [1 0;0 1];
% b = [1;1];
flag1 = true;
r = neuronas;
while epocas > 0 && flag1
W0 = W(:,end-r+1:end)';
% disp(W0)
b0 = b(:,end);
% disp(b0)
for it=1:numt
p = entradas(:,it);
% disp('p')
% disp(p)
t = objetivos(:,it);
% disp('t')
% disp(t)
a = hardlim(W0 * p + b0);
% disp('a')
% disp(a)
e = t - a;
% disp('e')
% disp(e)
W = horzcat(W,(W0 + e * p')');
b = horzcat(b,b0 + e);
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
end
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
flag1 = false;
end
epocas = epocas - 1;
end
W0 = W(:,end)';
% disp('W0')
% disp(W0)
b0 = b(:,end);
% disp('b0')
% disp(b0)
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
% disp('tfinal')
% disp(tfinal)
if epocas == 0
disp('Se alcanzo el numero de epocas')
else
disp('No se alcanzo el numero de epocas')
end
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
else
disp('La clasificacion no es correcta')
end
if flag1 == true
disp('No se cumple la tolerancia de '+string(tolerancia))
else
disp('Se cumple la tolerancia de '+string(tolerancia))
end
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
%
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
end

Problema 2

Elabore una función para clasificar vectores en con las siguientes características
Proponga un problema de clasificación con 8 clases, que sea linealmente separable, donde cada clase tenga dos vectores asociados para el entrenamiento.
Para este problema se usan los siguientes puntos y objetivos, donde la función problema2 hace uso de la función perceptron1 con la diferencia que usa los datos de retorno para realizar las gráficas
p1 = [40;60];
t1 = [0;0;0;0];
p2 = [40;65];
t2 = t1;
p3 = [20;-40];
t3 = [1;0;0;0];
p4 = [25;-40];
t4 = t3;
p5 = [5;80];
t5 = [0;1;0;0];
p6 = [-5;65];
t6 = t5;
p7 = [-40;-30];
t7 = [1;1;0;0];
p8 = [-40;-20];
t8 = t7;
p9 = [-20;-60];
t9 = [0;0;1;0];
p10 = [-20;-75];
t10 = t9;
p11 = [-75;20];
t11 = [1;0;1;0];
p12 = [-85;20];
t12 = t11;
p13 = [60;30];
t13 = [0;1;1;0];
p14 = [70;30];
t14 = t13;
p15 = [-60;60];
t15 = [1;1;1;0];
p16 = [-60;75];
t16 = t15;
t = [t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16];
p = [p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16];
problema2(p,t,100);
Existen 8 clases, por lo que se necesitan 4 neuronas Se alcanzo el numero de epocas La clasificacion no es correcta No se cumple la tolerancia de 1 neuronas 4
El video donde se observa el funcionamiento del código implementado se puede descargar en el siguiente enlace o ver en el siguiente enlace.

Problema 3

Resuelva el problema 2 para clasificar vectores en .
En el cápitulo 3 de Hagan hay un ejemplo de aplicación, páginas 3-1 a 3-6. Con esta idea, aplica la solución de ente probelma para clasificar naranjas y manzanas. Considera que los vectores de manzanas, están en el I octante, y los de naranjas en el III octante. Propon 2 entradas para cada clase.
clc, clear all
p1 = [4;1;1];
t1 = [1];
p2 = [1;4;1];
t2 = t1;
p3 = [-3;-4;2];
t3 = [0];
p4 = [-1;-1;2];
t4 = t3;
t = [t1,t2,t3,t4];
p = [p1,p2,p3,p4];
[W,b] = perceptron1(p,t,1000);
Existen 2 clases, por lo que se necesitan 1 neuronas No se alcanzo el numero de epocas La clasificacion es correcta Se cumple la tolerancia de 1
W0 = W(:,end)';
b0 = b(:,end);
syms p1l p2l p3l
eq = W0 * [p1l;p2l;p3l] + b0 == 0;
val = solve(eq,p3l)
val = 
[p1l,p2l] = meshgrid(-10:1:10);
p3l = double(subs(val));
figure
s = surf(p1l,p2l,p3l,'FaceAlpha',0.5)
s =
Surface with properties: EdgeColor: [0 0 0] LineStyle: '-' FaceColor: 'flat' FaceLighting: 'flat' FaceAlpha: 0.5000 XData: [21×21 double] YData: [21×21 double] ZData: [21×21 double] CData: [21×21 double] Show all properties
s.EdgeColor = 'none';
hold on
plot3(p(1,:),p(2,:),p(3,:),'o')
r = 2;
neuronas = r;
for i=1:neuronas
for j=1:2
figure
plot(W(1,i:r:end),'o', 'MarkerSize',10)
title('convergencia del peso '+string(j)+ ' de la neurona '+ string(i) )
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end
% [fil,col] = size(W);
for i=1:neuronas
figure
plot(b(1,:),'o', 'MarkerSize',10)
title('convergencia del bias '+string(i))
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
Se entrega el resultado, y el enlace a un video (o se inserta el video) para ver la aplicación.

Problema 4

Se muestran los siguiente códigos en MATLAB
Clasificación, dos clases en
Creamos datos de entrenamiento de forma artificial
close all, clear all, clc, format compact
% numero de puntos para cada clase
N = 20;
% definición aritficial de entradas y salidas
offset = 5; % separación para las clases
x = [randn(2,N) randn(2,N)+offset]; % entradas
y = [zeros(1,N) ones(1,N)]; % salidas
% Gráfica de entradas con PLOTPV (gráfica vectores para perceptron entradas/salidas)
figure
plotpv(x,y)
Definición de la red y entrenamiento
net = perceptron(); % perceptron vacio
view(net) % esquema de topologia de red, tipo Hagan
net.trainParam.showWindow = 0; % no muestra el cuadro de dialogo del entrenamiento
net_trained = train(net,x,y); % entreanmos la red y guardamos la red entrenada
view(net_trained) % esquema de topologia de red entrenada, tipo Hagan
Gráfica de frontera de desición
hold on
plotpc(net_trained.IW{1},net_trained.b{1}); % función para impeme
Clasificación, cuatro clases en
close all, clear all, clc, format compact
% numero de muestras en cada clase
K = 2;
% definición de las clases
q = .6; % separación de la clases
A = [rand(1,K)-q; rand(1,K)+q];
B = [rand(1,K)+q; rand(1,K)+q];
C = [rand(1,K)+q; rand(1,K)-q];
D = [rand(1,K)-q; rand(1,K)-q];
figure(1); % no queremos repetir este codigo
figure(2); % creamso dos figura para copiar en contenido
figure(1) % activamos la figura 1
% graficamos clases
plot(A(1,:),A(2,:),'bs');
hold on
grid on
plot(B(1,:),B(2,:),'r+')
plot(C(1,:),C(2,:),'go')
plot(D(1,:),D(2,:),'m*')
% texto de las clases
text(.5-q,.5+2*q,'Clase A')
text(.5+q,.5+2*q,'Clase B')
text(.5+q,.5-2*q,'Clase C')
text(.5-q,.5-2*q,'Clase D')
% se definenen las salidas para las clases
a = [0 1]';
b = [1 1]';
c = [1 0]';
d = [0 0]';
% % ¿por qué estas salidas no funcionan?
% a = [0 0]';
% b = [1 1]';
% d = [0 1]';
% c = [1 0]';
% % ¿por qué estas salidas no funcionan?
% a = [0 1]';
% b = [1 1]';
% d = [1 0]';
% c = [0 1]';
CloneFig(1,2) % copiamos la figura 1 a la figura 2
Entradas y salidas
% definen las entradas (combinación para las cuatro clases)
P = [A B C D];
% definen las salidas
T = [repmat(a,1,length(A)) repmat(b,1,length(B)) ...
repmat(c,1,length(C)) repmat(d,1,length(D)) ];
%plotpv(P,T);
% aquí sería bueno imprimir P y T para menos estradas, para apreciar como
% se deben concatenar los valores
Se crea el perceptron y se entrena
net = perceptron;
net.trainParam.showWindow = 0;
net_trained = train(net,P,T);
view(net_trained)
Gráficamos la frontera de desición
figure(1) % activamos la figura 1
plotpc(net_trained.IW{1},net_trained.b{1});
Se entrega el desarrollo del ejemplo del problema 2 y el desarroolo del ejemplo de de problema 3 con las herramientas antes descritas.

Referencias

F. Rosenblatt, “The perceptron: A probabilistic model for information storage and organization in the brain,” Psycho- logical Review, Vol. 65, pp. 386–408, 1958.
Libro de Matin Hagan et. al. enlace
Implemenatción de perceptron con MATLAB, enlace
Función para clonar figuras enlace

Funciones utilizadas

function CloneFig(inFigNum,OutFigNum)
% this program copies a figure to another figure
% example: CloneFig(1,4) would copy Fig. 1 to Fig. 4
% Matt Fetterman, 2009
% pretty much taken from Matlab Technical solutions:
% http://www.mathworks.com/support/solutions/en/data/1-1UTBOL/?solution=1-1UTBOL
hf1=figure(inFigNum);
hf2=figure(OutFigNum);
clf;
compCopy(hf1,hf2);
function compCopy(op, np)
%COMPCOPY copies a figure object represented by "op" and its % descendants to another figure "np" preserving the same hierarchy.
ch = get(op, 'children');
if ~isempty(ch)
nh = copyobj(ch,np);
for k = 1:length(ch)
compCopy(ch(k),nh(k));
end
end
end
end
function [W,b] = perceptron1(entradas,objetivos,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[r,numr] = size(entradas);
[n,numt] = size(objetivos);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*objetivos(exp,tt) + cont;
end
numClase(tt) = cont;
end
numClases = length(unique(numClase));
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
disp('Existen '+string(numClases) +' clases, por lo que se necesitan '+ string(neuronas) + ' neuronas')
% fin numero de clases
% disp(neuronas)
% Generar los pesos y desviaciones
% rng(0,'twister');
W = round((100-(-100)).*rand(r,neuronas) + (-100));
b = round((100-(-100)).*rand(neuronas,1) + (-100));
% size(W): columnas pesos(entradas), filas son neuronas
% W = numr x neuronas
% W = [0; 0];
% b = [0];
% W = [1 0;0 1];
% b = [1;1];
flag1 = true;
r = neuronas;
while epocas > 0 && flag1
W0 = W(:,end-r+1:end)';
% disp(W0)
b0 = b(:,end);
% disp(b0)
for it=1:numt
p = entradas(:,it);
% disp('p')
% disp(p)
t = objetivos(:,it);
% disp('t')
% disp(t)
a = hardlim(W0 * p + b0);
% disp('a')
% disp(a)
e = t - a;
% disp('e')
% disp(e)
W = horzcat(W,(W0 + e * p')');
b = horzcat(b,b0 + e);
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
end
if sum((W(:,end-r+1:end) - W(:,end - numt*r+1:end - numt*r + r)).^2) < tolerancia % Norma 2
% if sum((W(:,end) - W(:,end - numt)).^2) < tolerancia % Norma 2
% if sum((abs(W(:,end)) - W(:,end - numt)).^2) < tolerancia % Norma Infinito
flag1 = false;
end
epocas = epocas - 1;
end
W0 = W(:,end)';
% disp('W0')
% disp(W0)
b0 = b(:,end);
% disp('b0')
% disp(b0)
tfinal = hardlim(W(:,end-r+1:end)'*entradas + b(:,end));
% disp('tfinal')
% disp(tfinal)
if epocas == 0
disp('Se alcanzo el numero de epocas')
else
disp('No se alcanzo el numero de epocas')
end
if all(tfinal == objetivos)
disp('La clasificacion es correcta')
else
disp('La clasificacion no es correcta')
end
if flag1 == true
disp('No se cumple la tolerancia de '+string(tolerancia))
else
disp('Se cumple la tolerancia de '+string(tolerancia))
end
% plot(C1(1,:),C1(2,:), 'bo', 'MarkerSize',20)
%
% plot(C2(1,:),C2(2,:), 'gs','MarkerSize',20)
% plot(C3(1,:),C3(2,:), 'ro', 'MarkerSize',30, 'LineWidth',5)
% plot(C4(1,:),C4(2,:), 'ks','MarkerSize',30,'LineWidth',5)
end
function [] = problema2(p,t,epocas,tolerancia)
if nargin<4
tolerancia = 1;
end
[W,b] = perceptron1(p,t,epocas,tolerancia);
[n,numt] = size(t);
% numero de clases
numClase = zeros(1,numt);
for tt=1:numt
cont = 0;
for exp=1:n
cont = (2^(exp-1))*t(exp,tt) + cont;
end
numClase(tt) = cont;
end
marcadores = 'o+*.x_|sd^v<>ph'; %15 'o*.s';
colores = 'rbmk'; %7
numClases = length(unique(numClase));
unicos = unique(numClase);
% neuronas = ceil(log2(numClases));
syms n
eq = 1 + (n+1)*n/2 == numClases;
res = double(solve(eq,n));
sol = find(res >= 0);
neuronas = ceil(res(sol(1)));
r = neuronas;
disp('neuronas')
disp(neuronas)
W0 = W(:,end-r+1:end)';
b0 = b(:,end);
% cont = 0;
figure
for i=1:numClases
index = find(numClase == unicos(i));
% disp(index)
% disp(length(index))
% disp('Clase '+string(i))
% disp('longitud de '+string(length(index)))
% disp(index)
plot(p(1,index),p(2,index), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',10,'DisplayName','C'+string(i))
hold on
% for j=1:length(index)
% disp(p(:,index(j)))
% disp(marcadores(mod(i-1,15)+1))
% plot(p(1,index(j)),p(2,index(j)), string(marcadores(mod(i-1,15)+1)) + 'k', 'MarkerSize',20)
% hold on
% % disp(index(j))
% end
% disp(cont)
% cont = cont + 1;
end
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
% legend("C1","C2","C3","C4",'FontSize',5,'Location','southwest')
% axis([-12 12 -12 12])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
for i=1:neuronas
wlocal = W0(i,:);
b1 = b(i);
syms p1l p2l
eq = wlocal * [p1l;p2l] + b1 == 0;
val = solve(eq,p1l);
p2l = 10;
p1l = subs(val);
% p1l = p(:,1+(i-1)*2)
% p2l = p(:,(i)*2)
fimplicit(@(p1l,p2l) wlocal(1,1)*p1l + wlocal(1,2)*p2l + b1,[-100,100],colores(mod(i,4)+1))
quiver(p1l,p2l,wlocal(1,1),wlocal(1,2),0, 'MaxHeadSize',0.5,"Color",colores(mod(i,4)+1),'DisplayName','_'+ string(i)+'w')
end
legend('FontSize',5,'Location','bestoutside','NumColumns',1)
% [fil,col] = size(W);
for i=1:neuronas
for j=1:2
figure
plot(W(1,i:r:end),'o', 'MarkerSize',10)
title('convergencia del peso '+string(j)+ ' de la neurona '+ string(i) )
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end
% [fil,col] = size(W);
for i=1:neuronas
figure
plot(b(1,:),'o', 'MarkerSize',10)
title('convergencia del bias '+string(i))
% axis([0 length(W(1,i:r:end)) min(W(1,i:r:end)) max(W(1,i:r:end))])
grid on
g = gca;
g.XAxisLocation = 'origin';
g.YAxisLocation = 'origin';
g.Box = 'off';
% [f,c]=size(W(1,i:r:end));
% text(W(1,i:r:end)+0.06*([0:c-1]),W(1,i:r:end)+0.1,string([0:c-1]))
end
end